


//1、 ———————————————— 初始化列表

#include <iostream>
using namespace std;

typedef int DataType;
class Stack
{
public:
	//Stack(size_t capacity = 3) //默认构造
	Stack(size_t capacity)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}

	// 其他方法...
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

class MyQueue
{
public:
	//此时stack不具备默认构造，MyQueue也无法生成默认构造。
	// 初识化列表
	// 格式 冒号：开始，逗号分割
	// 初始化对象可以理解为每个对象中成员定义的地方
	//所有的成员，你可以在初始化列表或者函数体内初始化。
	// 但是1、引用 2、const 3、没有默认构造的自定义类型成员（必须显示传参调构造）

	//MyQueue(int n)
	MyQueue(int n = 20, int& rr)
		: _pushst(n)
		, _popst(n)
		, _size(0)   
		, _x(1)
		, _ref(rr)
	{
		//_size = 0;
	}
private:
	// 声明
	Stack _pushst;
	Stack _popst;
	int _size;    //_size 既可以在函数体中初始化，也可以在初始化列表中初始化
	const int _x; //const 成员变量必须在定义时初始化
	int& _ref;   //引用成员变量 必须在定义时初始化

};

int main()
{
	int xx = 0;

	MyQueue q1(10, xx);
	MyQueue q2; 

	return 0;
}


//// ———————————————— 2、给了默认构造
//#include <iostream>
//using namespace std;
//
//typedef int DataType;
//class Stack
//{
//public:
//	Stack(size_t capacity = 3) //默认构造
//	{
//		_array = (DataType*)malloc(sizeof(DataType) * capacity);
//		if (NULL == _array)
//		{
//			perror("malloc申请空间失败!!!");
//			return;
//		}
//		_capacity = capacity;
//		_size = 0;
//	}
//
//	// 其他方法...
//	~Stack()
//	{
//		if (_array)
//		{
//			free(_array);
//			_array = NULL;
//			_capacity = 0;
//			_size = 0;
//		}
//	}
//private:
//	DataType* _array;
//	int _capacity;
//	int _size;
//};
//
//class MyQueue
//{
//public:
//	// 经过调试我们发现，初始化列表，不管写不写，每个成员变量都会走一遍。
//	// 自定义类型的成员就会调用默认构造（没有默认构造则编译报错）
//	// 内置类型有缺省值，用缺省值，没有的话，看编译器
//	// 先走初始化列表 + 再走函数体
//	/*MyQueue()
//	{
//		_size = 0;
//	}*/
//
//	/*MyQueue()
//	{}*/
//
//	MyQueue()
//		: _size(1)
//	    , _ptr((int*)malloc(40))
//	{
//		memset(_ptr, 0, 40);
//	}
//
//private:
//	// 声明
//	Stack _pushst;
//	Stack _popst;
//
//	int _size = 0; //缺省值，给初始化列表用的
//	const int _x = 10;
//	
//	int* _ptr;
//
//};
//
//int main()
//{  
//	MyQueue q;
//
//	return 0;
//}
//






//// ———————————————————————— 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，
//// 与其在初始化列表中的先后次序无关
//
//#include <iostream>
//using namespace std; 
// 
//class A
//{
//public:
//	A(int a = 1)
//		:_a2(a)
//		, _a1(_a1)
//	{}
//	void Print() {
//		cout << _a1 << " " << _a2 << endl;
//	}
//private:
//	int _a2;
//	int _a1;
//};
//
//int main() {
//
//	A aa(1);
//	aa.Print();
//}





//  ————————————————————————————— 隐式类型转换和explict关键字
#include <iostream>
using namespace std;
class A 
{
public:
	A(int a) //单参数构造函数
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A (int a1,int a2) //多参数构造函数
		:_a(0)
		,_a1(a1)
		,_a2(a2)
	{} 

	A(const A& aa)
		:_a(aa._a)
	{
		cout << "const A& aa" << endl;
	}

private:
	int _a;
	int _a1;
	int _a2;
};


//int main() 
//{
//	// 隐式类型转换
//	A aa1(1);
//	A aa2 = aa1; //拷贝构造
//
//	// 3 构造一个A的临时对象，在用这个临时对象拷贝构造aa3
//	// 编译器在遇到连续构造 + 拷贝构造 -> 优化为直接构造
//	A aa3 = 3; // 隐式类型转换，内置类型转换为自定义类型
//
//	// raa 引用的是类型转换中用3构造的临时对象
//	//A& raa = 3;
//	const A& raa = 3; //有直接构造
//
//	// A aa4 = "1111" ;
//
//	A aaa1(1, 2);
//    //A aaa2 = (1, 2);  // 相当于调用单参数构造，就传了一个 2
//	A aaa2 = { 1,2 };
//	A aaa2{ 1,2 }; //可以省略
//	const A& aaa3 = { 1,2 };
//	 
//	return 0;
//}


//class Stack
//{
//public:
//	//void push(A& aa) //如果没有const，比如传2的时候会发生错误，因为出现权限放大
//	void push(const A& aa)
//	{
//		// ...
//	}
//};


//int main()
//{
//	Stack st;
//	A a1(1);
//	st.push(a1);
//	st.push(2);
//
//	A aa1(1, 2);
//	st.push(aa1);
//	st.push({ 1,2 });
//
//}



//class BB
//{
//public:
//	BB()
//	{
//
//	}
//private :
//	int _b1 = 1;
//	int* _ptr = (int*)malloc(40);
//	A _a1 = 1;
//	A  _a2 = { 1,2 };
//	A _a3 = _a2;
//};
//
